Skip to content

Delegated results: remind for linked children a stop lost, and tighten the reminder - #641

Merged
scuttletoby merged 5 commits into
mainfrom
fix/625-delegated-results-followups
Nov 20, 2026
Merged

scuttletoby merged 5 commits into
mainfrom
fix/625-delegated-results-followups

Conversation

@scuttletoby

@scuttletoby scuttletoby commented Nov 20, 2026 •

Copy link
Copy Markdown
Owner

Fixes #625
Part of #386

Follow-ups from the review of #622. Every point of #625 is fixed below, except item 8 of the review (no change needed) and the table padding (reason given).

Major: crash gap for linked children

delegate_task to a linked environment makes the thread there before it records the task here. A server that stopped in between left a thread there that no task here follows, and nothing told the parent.

New DelegatedOrphanScan, started a few minutes after server start:

  • It reads each linked environment's t3_thread_list page by page (allProjects, 100 a page, at most 20 pages, 10 s a page). It stops at threads last updated over a day before the start.
  • It keeps threads whose delegatedFrom names a thread here and that were made before this server started, with one minute of tolerance for clocks that differ between machines (CLOCK_SKEW_MS). A launch after the start is recorded by this server long before the first scan (3 min after start), so it is never raced.
  • For each parent, it subtracts the linked children its tasks already follow. That comes from a new DelegatedResultsStore.remoteChildrenOf, a narrow SQL read, settled tasks included. A parent with orphans gets a queued message through WaitDelivery (at most 10 orphans each). It names each thread and the tools that read and stop it.
  • Each orphan is named once. Every orphan has its own key (a digest of environment and thread there), and a message's ids list the keys in it: delegated-orphan:<parent>:<key>.<key>…. Before a send, DelegatedResultsStore.sentIds reads the parent's message ids and accepted receipt ids with that prefix. Only orphans not named yet are sent, so a grown set (a machine that answers late, a one-day window that moved after a restart) sends only the new ones.
  • A busy parent is not held, including one waiting on a question. WaitDelivery sends with mode: "queue" (queue_after_active), so the message waits behind the run and is read once it ends. Orphans are worked out before the parent's shell is read, so a busy parent with none costs nothing.
  • It scans again (10 min apart, at most 6 scans) while an environment did not answer, answered only its first page (cut-short), or a parent could not be read. After the last scan, a warning names the environments and parents still unchecked. The next start scans them again.
  • It sends nothing while server.waitFor is off, while Linked environments is off, or on a held start (--hold-work). It never writes to a parent that is stopped, archived or deleted.

Upstream's "record before launch" change ("recover remote delegated launches after source restart") is not ported. Upstream has not merged it yet and it is large. The scan closes the gap without touching upstream's launch path, and it also covers threads lost before this PR. When a sync brings it, slim the scan or drop it (noted in the scan's header and docs/fork/README.md).

The orphan message's wording is neutral ("delegate_task did not record it here"): a failed record leaves such a thread too, not only a stopped server.

Minors

  1. No delivery state: results with no state now count as unread for one day (a wait whose acknowledgement failed). The review suggested only a wording change, but the issue says they are "never reminded", so the logic changed too. task_list's unrecorded text says "an old row, or a wait that never acknowledged it".
  2. Busy: an open question still holds the reminder, but background work the parent left running does not, because no run end may come. Docs say what counts as busy.
  3. Restart: the startup check also reads parents with a recent unread result from the subagent table (parentsWithUnreadResults), not only those with a reserved wake. Parents that already have a timer are skipped.
  4. Wording: the reminder says the result "may not have reached this thread".
  5. Remote slots: a remote task that ended here while its stop there is still owed (stoppedThere: false) is read there. After one read on an environment times out, that environment's other tasks are unknown without waiting again.
  6. Orphan search depth: task_list now reads up to 5 pages (500 threads) per environment, and next names any environment where it read only the newest 500, and separately any environment whose later page did not answer. The startup scan reads up to 2000 and logs "the page limit was reached" only for that limit; a page that did not answer is scanned again instead.
  7. Surviving mutants: a test now kills each one:
    • a stopped parent is added to watched and re-triggered by its next run end;
    • a non-terminal run.updated is no trigger;
    • the orphan filter checks the environment id (same thread id from another environment);
    • settled tasks are not listed without includeSettled (exact key set);
    • the startup scan's FiberMap.has skip (checked by mutation: removing it fails "the startup scan leaves a parent to the check an event already moved later").
  8. waitFor turned on later: no change, as the review concluded.
  9. Tool description: the description now uses the review's shorter wording. The budget went from 2451 to 2406 bytes, with the new orphan note included. The docs now say to use task_list for children per place and wait_list for this agent's own slot use.
  10. FORK_CHANGES.md padding: not reverted. Re-padding the table back would change all rows again and conflict with every open PR that edits it. This PR appends its link to row 26 and keeps the existing column widths.

General vs project

Everything here is general fork behaviour for any T3 install with linked environments. There are no project names, hosts or paths, and no settings beyond upstream's server.waitFor. New code lives in fork-owned paths (apps/server/src/fork/delegatedResults/, the fork's task_list toolkit). It builds on upstream's completionDelivery, isLiveSubagentShell, getRecoveryThreadIds, t3_thread_list and PeerForwarding.

State question (in tests)

  • Runs again: every orphan's key is already in a sent id, so nothing is sent. The owed set gives the same ids, and WaitDelivery's message and receipt lookups dedupe them.
  • Restart, window moved: a test drops an orphan out of the one-day window (its page is never read) and adds a new one; only the new one is sent.
  • Stopped half-way: 12 orphans make two messages; with the first sent, only the second goes out. A receipt whose message row is missing still counts as sent; a rejected receipt does not. A send that answers retry, an environment that does not answer (fully), or an unreadable parent leads to another scan.
  • This PR's earlier format: a message for exactly the current set (delegated-orphans:<parent>:<set digest>) counts as sent. That format was never on main.
  • Old, empty or missing state: covered cases:
    • rows with no delivery state;
    • rows older than a day (no reminder);
    • an empty table (no parent);
    • an unreadable shell or task list (unreadable, retried, nothing sent);
    • a deleted or archived parent (gone);
    • a stopped parent (held, never restarted); a busy one (queued);
    • a held start (--hold-work: nothing read, nothing sent);
    • Linked environments off or waitFor off (off);
    • an expired link (skipped);
    • threads made after the start, and threads from another environment's parent (excluded).
  • DelegatedResultsStore runs both SQL reads against the real schema in memory.

Tests fail on the old code

Review fix round: this PR's previous sources with the new tests: 20 of 75 failed. One mutant of the new code per fix (no per-orphan record, no earlier-format check, busy held again, cut-short not rescanned, no final warning, busy checked before orphans, old wording, no clock tolerance, no held-start skip, cut-short as limit, receipts ignored, rejected receipts counted): 12 of 12 killed. This head: 75/75 pass; typecheck, lint, knip and format are clean.

First round:
Main's versions of delegatedResults.ts, DelegatedResultReminder.ts, taskList.ts and tools.ts were put back and the suites were run against them: 22 of 62 tests failed. They span all five suites:

  • delegatedResults: none remindable, background work not busy, "may" wording, orphan ids, orphansOf environment checks;
  • DelegatedResultReminder: a wait task with no state, background work, a startup parent with no wake;
  • DelegatedOrphanScan: 7 tests;
  • taskList: stoppedThere, one timeout per environment, the partial note;
  • the tool budget.

With this branch: 62/62 pass, and typecheck, lint, knip and format are clean.

🤖 Generated with Claude Code

scuttletoby and others added 3 commits November 20, 2026 15:14
…n the reminder

- At start, read each linked environment's threads made before the start; a parent here
  that one names as delegatedFrom but no task follows gets one queued message (ids from the
  orphans, so a rerun or the next restart never repeats it). Retries while an environment
  does not answer or the parent is busy.
- The startup check also finds parents with unread results but no reserved wake.
- Results with no delivery state count as unread for a day; an open question holds the
  reminder, background work does not.
- task_list: a linked child still running there is read there; one timeout marks the rest
  of that environment unknown; the orphan search says when it read only the newest threads.

Fixes #625
Part of #386

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
…ults-followups

# Conflicts:
#	FORK_CHANGES.md
#	apps/server/src/fork/forkLayers.ts
@scuttletoby

Copy link
Copy Markdown
Owner Author

Review of #641 (correctness and state lens): SAFE

Head aa7993748c. Nothing here loses or corrupts data. Retries are bounded, and there is no schema change. The worst cases are a repeated reminder or a missed one, so this is safe to merge. The two majors below are about the orphan scan doing what #625 asks in every case. Fix them here or in a follow-up issue.

Blocking

None.

Major

  1. A parent can be told about the same orphan twice. DelegatedOrphanScan.ts:114 takes the message id from a digest of the whole orphan set. So whenever the set grows, the parent gets a new message that repeats the orphans it was already told about. The PR's own test asserts this (DelegatedOrphanScan.test.ts:363-372: env C does not answer the first scan, and the second message names lost-1 again). It happens within one boot when one linked machine answers late. Across restarts it happens whenever a new orphan appears or an old one leaves the one-day window (sinceMs moves with each start). The message says "their results will not arrive", so a parent that sees it twice may redo the work twice. Fix: give each orphan its own reminder key, for example check each orphan's own message id and send only the ones not sent yet. Or hold a parent's message until every environment that names it has answered.
  2. Once the scans run out, a busy parent or an unreachable machine is dropped with no log. run (DelegatedOrphanScan.ts:209-216) stops after attempts scans (about 53 min) and logs nothing about what it left unchecked. Busy includes an open question (parentBusy, delegatedResults.ts:119). A parent waiting on a person for over an hour, which is common, never hears about its orphan in that boot. A later start sees the orphan only if its thread there changed in the last day. A machine offline for over an hour is the same case. The partial state from a later page that timed out (linkedThreads.ts:50) is never scanned again either, because needsAnother looks only at unreachable. That is "unknown treated as fine". Fix: at least log a warning on the last attempt naming the parents and environments left over. Better: hand busy parents to the reminder's run-end trigger (DelegatedResultReminder's watched). Or deliver anyway: WaitDelivery queues, and the PR's own comment at delegatedResults.ts:116 says a queued message is safe.

Minor

  1. A busy parent with nothing to report still forces another scan. checkParent (DelegatedOrphanScan.ts:109) checks busy before it reads remoteChildrenOf and orphansOf (lines 110-113). Any parent with a followed linked child updated in the last day therefore holds needsAnother true while it runs, so all 6 scans run for nothing. Fix: work out the orphans first and return none before the busy check.
  2. Wrong text after a failed record. When delegated_task.remote.request fails, RemoteDelegation stops the thread there (RemoteDelegation.ts ~416-426, and record-found-no-task ~446) and the parent gets an error. That stopped thread still has delegatedFrom, so after the next restart the scan reminds the parent of it. The text (orphanReminderText) says "the server stopped during delegate_task", which is wrong in this case. Fix: use neutral wording ("a delegate_task whose record here was lost or failed"), or skip threads that are already stopped there.
  3. Clock skew can hide a real orphan. linkedThreads.ts:55-56 compares the peer's createdAt with this server's start time. After a fast restart, with the peer's clock a few seconds ahead, a real orphan counts as "made after the start" and is skipped for good in this boot. That is rare, but worth a tolerance (for example startedAtMs - skew), or say so in a comment.
  4. The held-start skip has no test. Mutant: removing if (heldFromBoot) return; (DelegatedOrphanScan.ts:233) leaves every test green. The layer itself is never tested.
  5. The partial log line is misleading. DelegatedOrphanScan.ts:191-195 logs "read only the newest threads" with threads: maxPages*100. A partial caused by a later page timing out says the same. Fix: log the reason (limit or no answer).
  6. The upstream gap is described only in the PR body. The statement is accurate: upstream PR 30249 ("recover remote delegated launches after source restart") is still open. But nothing in the repo says this scan is the stopgap until upstream records before launch. Fix: add one line in the DelegatedOrphanScan.ts header or the FORK_CHANGES.md row, so the next upstream sync knows to drop or slim the scan.

Checked and fine

  • Dedupe: the same orphan set gives the same ids, and WaitDelivery looks for the message, then the receipt, before it sends. A rerun, a restart, or a kill between send and mark sends nothing new (test lines 215-220).
  • When it stays silent: off while waitFor is off, while Linked environments is off (links fails, so OFF) and on heldFromBoot. Never sends to a stopped (held, not retried), archived or deleted parent. Threads made after the start and a same-id parent in another environment are excluded (both mutants killed).
  • Retry bounds: at most 6 scans, 10 min apart, 4 environments at a time, at most 20 pages of 10 s each. No tight loop, no growing state. nextCursor <= cursor stops a peer that ignores the cursor.
  • Real wiring: the scan's thread-less scope works with the real PeerForwarding.call (loadCaller returns no caller when there is no thread). After the merge, forkLayers.ts wires ForkFeatures (from main), DelegatedOrphanScan (routes) and DelegatedResultReminder (runtime services).
  • Store: reads only, no migration (the "No database schema changes" check is green). There is no persisted shape for a downgrade to trip on, and the old code ignores the new message ids.
  • No delivery state: a mode: "wait" task is acknowledged by the wait's readTask(..., true). "None" is therefore an old row or a failed acknowledgement, and in that second case the agent saw an error, not the result. The upsert keeps null states (COALESCE), and omitSettledSubagents keeps them too. A reminder can repeat only when the set of unread tasks changes, and only within one day.
  • task_list: unknown is never counted as live or ended. One timeout marks the rest of that machine unknown. A remote task whose stoppedThere is still false is read there.
  • Tests: the 5 suites pass here (61/61). CI is green. Mutants: 13 of 15 killed. The survivors are the held-start skip (item 6) and dropping child_thread_id IS NULL from remoteChildrenOf, which is equivalent: local rows have no remoteChild, so they are filtered out anyway.

… what is left

- Each orphan gets its own key in the message and command ids; before a send the
  scan reads the parent's sent message ids and accepted receipts, so a grown set
  (late machine, moved one-day window after a restart) sends only the new ones.
  At most 10 orphans per message; the first scan's per-set id still counts.
- A busy parent (also one waiting on a question) is no longer held: the queued
  message is read once its run ends. Orphans are worked out first, so a busy
  parent with none forces no rescan.
- A later page that does not answer is its own state (cut-short): scanned again,
  and named in task_list's next. After the last scan a warning names the
  environments and parents still unchecked. The page-limit line says so.
- Neutral wording (a failed record also leaves an orphan), a minute's clock
  tolerance between machines, a test for the held-start skip, and the upstream
  gap in the docs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@scuttletoby

Copy link
Copy Markdown
Owner Author

Fix for the correctness and state review

Head bf21a2ba3e47504039856f32968fc43f20367611. Both majors and every minor are fixed. Each fix has a test that fails without it.

Major 1: an orphan is never named twice

  • Each orphan now has its own 12-hex key (a digest of environment and thread there). A message's id lists the keys of the orphans in it: delegated-orphan:<parent>:<key>.<key>…. At most 10 orphans go in one message, and each one is named by name.
  • Before a send, the scan reads which keys were already named to this parent. It reads the parent's message ids and its accepted command receipt ids with that prefix (DelegatedResultsStore.sentIds, a read of indexed columns, with no schema change). Only orphans not named yet are sent.
  • So a grown set sends only the new ones. That covers a machine that answers late in one start, and a moved one-day window after a restart. The PR's own test (DelegatedOrphanScan.test.ts, "scans after the delay…") now expects the second message to name lost-c and not lost-1.
  • State question:
    • Runs again: every key is named already, so nothing is sent.
    • Restart, window moved: a test drops lost-1 out of the window (its page is never read) and adds lost-3. Only lost-3 is sent.
    • Killed half-way: 12 orphans make two messages. If the first was sent, only the second goes out. If only the first message's receipt survived and its row did not, it still counts as sent.
    • A refused receipt names nobody.
    • Old state in this PR's earlier format (one message per whole set, delegated-orphans:<parent>:<set digest>): a message for exactly the current set counts as sent. If the set grew since, each orphan is named once more, then never again. That format was never on main.

Major 2: no silent give-up

  • A busy parent is no longer held. That includes a parent waiting on a question to a person. Its run's end changes nothing about an orphan, and WaitDelivery sends with mode: "queue" (queue_after_active). The message waits in the parent's queue and is read once that run is over, which is "deliver once it is free" with no extra timers or loops. A stopped, archived or deleted parent still gets nothing.
  • A later page that times out is now its own state (cut-short, separate from the page limit limit). It causes another scan, as an environment that did not answer does. What its first page showed is named at once, and the rest once it answers (test: "scans again while an environment answers only its first page").
  • After the last scan, if anything is still unchecked, it logs one warning: "delegated orphan scan stopped with work unchecked until the next start". The warning names the environments that did not answer, the ones that were cut short, and the parents that could not be read. The next start scans them again within its one-day window.

Minors

  1. Busy parent with no orphans: the orphans are worked out first. A parent with none, or with all already named, needs no shell read and no further scan. Test: a busy parent with no orphan gets a single scan.
  2. Wording: the text is now neutral ("delegate_task did not record it here"). It no longer says "the server stopped", because a failed record (which stops the thread there) also leaves such a thread. The text says "1 thread … was" for a single orphan.
  3. Clock difference between machines: a thread counts as made before the start up to 60 s after it (CLOCK_SKEW_MS). A launch in that minute was recorded long before the first scan (3 min after start), so nothing is raced. The only extra thread it can name is one whose record failed, and the neutral wording covers that. Test: a thread stamped 30 s after the start is named; one at start + 60 s + 1 ms is not.
  4. Held start: layerWith(options) is now tested. A normal start scans and sends. A start with heldFromBoot reads nothing and sends nothing.
  5. The partial log line: the warning now says "the page limit was reached" and fires only for limit. A cut-short read is scanned again, and appears in the final warning if it is still cut short. A test asserts that the page-limit line is absent for a cut-short read. task_list had the same mix-up. Its next now names a cut-short environment separately ("A later page of … did not answer").
  6. Upstream gap: noted in the DelegatedOrphanScan.ts header and in docs/fork/README.md. Upstream's delegate_task also launches there before it records here, and its fix is not merged. When a sync brings it, slim the scan or drop it.

Tests fail on the old code

  • The PR's earlier sources with the new tests: I put back the five changed source files from the previous head (aa79937) and ran the five suites with the new tests: 20 of 75 tests failed.
  • Mutants of the new code, one per fix:
    • no per-orphan record (the set digest again): 4 failed (the PR's own run test, restart with a moved window, stop half-way);
    • check for the earlier format removed: 2 failed;
    • busy parent held again: 1 failed;
    • cut-short read not scanned again: 1 failed;
    • no final warning: 1 failed;
    • busy checked before orphans: 2 failed (one only by a rescan that ran into the time limit);
    • old wording: 1 failed;
    • no clock tolerance: 1 failed;
    • held-start skip removed: 1 failed;
    • cut-short counted as the page limit: 2 failed;
    • sentIds ignores receipts: 1 failed;
    • sentIds counts rejected receipts: 1 failed.
    • All 12 mutants were killed.
  • This head: 75/75 pass; typecheck, lint, knip and format are clean; CI is green (26 checks pass, the rest are skipped by path).

@scuttletoby
scuttletoby merged commit 18acedf into main Nov 20, 2026
38 checks passed
scuttletoby added a commit that referenced this pull request Nov 21, 2026
…n the reminder (#641)

* Delegated results: remind for linked children a stop lost, and tighten the reminder

- At start, read each linked environment's threads made before the start; a parent here
  that one names as delegatedFrom but no task follows gets one queued message (ids from the
  orphans, so a rerun or the next restart never repeats it). Retries while an environment
  does not answer or the parent is busy.
- The startup check also finds parents with unread results but no reserved wake.
- Results with no delivery state count as unread for a day; an open question holds the
  reminder, background work does not.
- task_list: a linked child still running there is read there; one timeout marks the rest
  of that environment unknown; the orphan search says when it read only the newest threads.

Fixes #625
Part of #386

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* FORK_CHANGES: link the delegated results follow-ups on their row

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Delegated orphans: name each orphan once, queue for busy parents, log what is left

- Each orphan gets its own key in the message and command ids; before a send the
  scan reads the parent's sent message ids and accepted receipts, so a grown set
  (late machine, moved one-day window after a restart) sends only the new ones.
  At most 10 orphans per message; the first scan's per-set id still counts.
- A busy parent (also one waiting on a question) is no longer held: the queued
  message is read once its run ends. Orphans are worked out first, so a busy
  parent with none forces no rescan.
- A later page that does not answer is its own state (cut-short): scanned again,
  and named in task_list's next. After the last scan a warning names the
  environments and parents still unchecked. The page-limit line says so.
- Neutral wording (a failed record also leaves an orphan), a minute's clock
  tolerance between machines, a test for the held-start skip, and the upstream
  gap in the docs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
scuttletoby added a commit that referenced this pull request Nov 21, 2026
…n the reminder (#641)

* Delegated results: remind for linked children a stop lost, and tighten the reminder

- At start, read each linked environment's threads made before the start; a parent here
  that one names as delegatedFrom but no task follows gets one queued message (ids from the
  orphans, so a rerun or the next restart never repeats it). Retries while an environment
  does not answer or the parent is busy.
- The startup check also finds parents with unread results but no reserved wake.
- Results with no delivery state count as unread for a day; an open question holds the
  reminder, background work does not.
- task_list: a linked child still running there is read there; one timeout marks the rest
  of that environment unknown; the orphan search says when it read only the newest threads.

Fixes #625
Part of #386

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* FORK_CHANGES: link the delegated results follow-ups on their row

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Delegated orphans: name each orphan once, queue for busy parents, log what is left

- Each orphan gets its own key in the message and command ids; before a send the
  scan reads the parent's sent message ids and accepted receipts, so a grown set
  (late machine, moved one-day window after a restart) sends only the new ones.
  At most 10 orphans per message; the first scan's per-set id still counts.
- A busy parent (also one waiting on a question) is no longer held: the queued
  message is read once its run ends. Orphans are worked out first, so a busy
  parent with none forces no rescan.
- A later page that does not answer is its own state (cut-short): scanned again,
  and named in task_list's next. After the last scan a warning names the
  environments and parents still unchecked. The page-limit line says so.
- Neutral wording (a failed record also leaves an orphan), a minute's clock
  tolerance between machines, a test for the held-start skip, and the upstream
  gap in the docs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
scuttletoby added a commit that referenced this pull request Nov 21, 2026
…n the reminder (#641)

* Delegated results: remind for linked children a stop lost, and tighten the reminder

- At start, read each linked environment's threads made before the start; a parent here
  that one names as delegatedFrom but no task follows gets one queued message (ids from the
  orphans, so a rerun or the next restart never repeats it). Retries while an environment
  does not answer or the parent is busy.
- The startup check also finds parents with unread results but no reserved wake.
- Results with no delivery state count as unread for a day; an open question holds the
  reminder, background work does not.
- task_list: a linked child still running there is read there; one timeout marks the rest
  of that environment unknown; the orphan search says when it read only the newest threads.

Fixes #625
Part of #386

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* FORK_CHANGES: link the delegated results follow-ups on their row

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Delegated orphans: name each orphan once, queue for busy parents, log what is left

- Each orphan gets its own key in the message and command ids; before a send the
  scan reads the parent's sent message ids and accepted receipts, so a grown set
  (late machine, moved one-day window after a restart) sends only the new ones.
  At most 10 orphans per message; the first scan's per-set id still counts.
- A busy parent (also one waiting on a question) is no longer held: the queued
  message is read once its run ends. Orphans are worked out first, so a busy
  parent with none forces no rescan.
- A later page that does not answer is its own state (cut-short): scanned again,
  and named in task_list's next. After the last scan a warning names the
  environments and parents still unchecked. The page-limit line says so.
- Neutral wording (a failed record also leaves an orphan), a minute's clock
  tolerance between machines, a test for the held-start skip, and the upstream
  gap in the docs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

#386 follow-ups from #622: crash gap for linked children, reminder edge cases, test gaps

1 participant